home *** CD-ROM | disk | FTP | other *** search
/ Aminet 35 / Aminet 35 (2000)(Schatztruhe)[!][Feb 2000].iso / Aminet / game / shoot / ADescentSrc.lha / descent / bios / joyc.c < prev    next >
C/C++ Source or Header  |  1998-04-09  |  12KB  |  558 lines
  1. /*
  2. THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
  3. SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
  4. END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
  5. ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
  6. IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
  7. SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
  8. FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
  9. CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
  10. AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.  
  11. COPYRIGHT 1993-1998 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
  12. */
  13. /*
  14.  * $Source: /usr/CVS/descent/bios/joyc.c,v $
  15.  * $Revision: 1.4 $
  16.  * $Author: tfrieden $
  17.  * $Date: 1998/04/09 16:10:48 $
  18.  * 
  19.  * Routines for joystick reading.
  20.  * 
  21.  * $Log: joyc.c,v $
  22.  * Revision 1.4  1998/04/09 16:10:48  tfrieden
  23.  * Preparing for pads
  24.  *
  25.  * Revision 1.3  1998/03/13 23:48:40  tfrieden
  26.  * fixed hat problems
  27.  *
  28.  * Revision 1.2  1998/03/13 14:46:28  hfrieden
  29.  * Modified Joystick support for FlighStick
  30.  *
  31.  * Revision 1.1.1.1  1998/03/03 15:11:50  nobody
  32.  * reimport after crash from backup
  33.  *
  34.  * Revision 1.2  1998/02/28 00:26:59  hfrieden
  35.  * Support for Analog Joysticks added
  36.  *
  37.  * 
  38.  */
  39.  
  40.  
  41. #pragma off (unreferenced)
  42. static char rcsid[] = "$Id: joyc.c,v 1.4 1998/04/09 16:10:48 tfrieden Exp $";
  43. #pragma on (unreferenced)
  44.  
  45. #include <stdlib.h>
  46. #include <stdio.h>
  47. /*#include <joystick.h>*/
  48. #include <fcntl.h>
  49.  
  50. //#define ARCADE 1
  51.  
  52. #include "types.h"
  53. #include "mono.h"
  54. #include "joy.h"
  55. #include "args.h"
  56. #include "AJoystick.h"
  57. #include "amiga_sega.h"
  58. #include <inline/macros.h>
  59.  
  60. #ifndef DOS_BASE_NAME
  61. #define DOS_BASE_NAME DOSBase
  62. #endif
  63.  
  64. extern void *DOSBase;
  65.  
  66. #define Delay(timeout) \
  67.     LP1NR(0xc6, Delay, long, timeout, d1, \
  68.     , DOS_BASE_NAME)
  69.  
  70.  
  71. struct AJoyData *JP;
  72. int NumAxis = 2;
  73.  
  74. char joy_installed = 0;
  75. char joy_present = 0;
  76.  
  77. //#define MAX_BUTTONS 16
  78. #define MAX_BUTTONS 30
  79.  
  80. typedef struct Button_info {
  81.     ubyte       ignore;
  82.     ubyte       state;
  83.     ubyte       last_state;
  84.     int     timedown;
  85.     ubyte       downcount;
  86.     ubyte       upcount;
  87. } Button_info;
  88.  
  89. typedef struct Joy_info {
  90.     ubyte           present_mask;
  91.     ubyte           slow_read;
  92.     int         max_timer;
  93.     int         read_count;
  94.     ubyte           last_value;
  95.     Button_info buttons[MAX_BUTTONS];
  96.     int         axis_min[4];
  97.     int         axis_center[4];
  98.     int         axis_max[4];
  99. } Joy_info;
  100.  
  101. Joy_info joystick;
  102.  
  103. int joy_buttons;
  104.  
  105. extern int joy_retries;
  106.  
  107. int joystick_fd0,joystick_fd1;
  108.  
  109. void myjoy_handler(fix ticks_this_time)
  110. {
  111.     ubyte value;
  112.     int i, state;
  113.     Button_info * button;
  114.  
  115.     ReadAJoystick(AJOYUNIT1, JP);
  116.  
  117.     value = 0;
  118.     if (JP->button1) value |= 0x01;
  119.     if (JP->button2) value |= 0x02;
  120.     if (JP->button3) value |= 0x04;
  121.     if (JP->button4) value |= 0x08;
  122.  
  123.     joy_buttons = value;
  124.  
  125.     for (i=0; i<MAX_BUTTONS; i++ )  {
  126.         button = &joystick.buttons[i];
  127.         if (!button->ignore) {
  128.             if ( i < 5 )
  129.                 state = (value >> i) & 1;
  130.             else if (i==(value+4))
  131.                 state = 1;
  132.             else
  133.                 state = 0;
  134.  
  135.             if ( button->last_state == state )  {
  136.                 if (state) button->timedown += ticks_this_time;
  137.             } else {
  138.                 if (state)  {
  139.                     button->downcount += state;
  140.                     button->state = 1;
  141.                 } else {
  142.                     button->upcount += button->state;
  143.                     button->state = 0;
  144.                 }
  145.                 button->last_state = state;
  146.             }
  147.         }
  148.     }
  149. }
  150.  
  151. void joy_get_cal_vals(int *axis_min, int *axis_center, int *axis_max)
  152. {
  153.     int i;
  154. #ifdef JOY_DEBUG
  155.     printf("joy_get_cal_vals():");
  156. #endif
  157.  
  158.     for (i=0; i<4; i++)     {
  159.     #ifdef JOY_DEBUG
  160.         printf("min=%d center=%d max=%d\n", joystick.axis_min[i], joystick.axis_center[i], joystick.axis_max[i]);
  161.     #endif
  162.         axis_min[i] = joystick.axis_min[i];
  163.         axis_center[i] = joystick.axis_center[i];
  164.         axis_max[i] = joystick.axis_max[i];
  165.     }
  166. }
  167.  
  168. void joy_set_cal_vals(int *axis_min, int *axis_center, int *axis_max)
  169. {
  170.     int i;
  171.  
  172.     for (i=0; i<4; i++)     {
  173.         joystick.axis_min[i] = axis_min[i];
  174.         joystick.axis_center[i] = axis_center[i];
  175.         joystick.axis_max[i] = axis_max[i];
  176.     }
  177. }
  178.  
  179.  
  180. ubyte joy_get_present_mask()
  181. {
  182. #ifdef JOY_DEBUG
  183.     printf("Present_Mask = %d\n",
  184.         (NumAxis==4)?JOY_ALL_AXIS:(JOY_1_X_AXIS+JOY_1_Y_AXIS));
  185. #endif
  186.  
  187.     return (NumAxis==4)?JOY_ALL_AXIS:(JOY_1_X_AXIS+JOY_1_Y_AXIS);
  188. }
  189.  
  190. void joy_set_timer_rate(int max_value ) {
  191.     joystick.max_timer = max_value;
  192. }
  193.  
  194. int joy_get_timer_rate()    {
  195.     return joystick.max_timer;
  196. }
  197.  
  198.  
  199. void joy_flush()    {
  200.     int i;
  201.     if (!joy_installed) return;
  202.  
  203.     for (i=0; i<MAX_BUTTONS; i++ )  {
  204.         joystick.buttons[i].ignore = 0;
  205.         joystick.buttons[i].state = 0;  
  206.         joystick.buttons[i].timedown = 0;   
  207.         joystick.buttons[i].downcount = 0;  
  208.         joystick.buttons[i].upcount = 0;    
  209.     }
  210. }
  211.  
  212. ubyte joy_read_raw_buttons()    {
  213.     return joy_buttons;
  214. }
  215.  
  216. void joy_set_slow_reading(int flag)
  217. {
  218. }
  219.  
  220. ubyte joystick_read_raw_axis( ubyte mask, int * axis )
  221. {
  222.     if (!joy_installed||!joy_present) return 0;
  223.  
  224.     ReadAJoystick(AJOYUNIT1, JP);
  225.     axis[0] = (int)JP->y;
  226.     axis[1] = (int)JP->x;
  227.  
  228.     joy_buttons=0;
  229.     if (JP->button1) joy_buttons |= 0x01;
  230.     if (JP->button2) joy_buttons |= 0x02;
  231.     if (JP->button3) joy_buttons |= 0x04;
  232.     if (JP->button4) joy_buttons |= 0x08;
  233.  
  234.     if (NumAxis>2) {
  235.         ReadAJoystick(AJOYUNIT0, JP);
  236.         axis[2] = (int)JP->y;
  237.         axis[3] = (int)JP->x;
  238.  
  239.     } else {
  240.         axis[2] = 0/*axis[0]*/; axis[3]=0/*axis[1]*/;
  241.     }
  242. #ifdef JOY_DEBUG
  243.     printf("joystick_read_raw_axis(%d): %d %d %d %d\n", (int)mask,
  244.         axis[0], axis[1], axis[2], axis[3]);
  245. #endif
  246.     return (NumAxis==4)?JOY_ALL_AXIS:(JOY_1_X_AXIS+JOY_1_Y_AXIS);
  247. }
  248.  
  249. void (*joy_handler)(fix);
  250.  
  251. int joy_init(void)
  252. {
  253.     int i,t;
  254.     int temp_axis[4];
  255.  
  256.     mouse_switch_off();
  257.     joy_flush();
  258.  
  259.     for (i=0; i<MAX_BUTTONS; i++ )  
  260.         joystick.buttons[i].last_state = 0;
  261.  
  262.     if ( !joy_installed )   {
  263.         atexit(joy_close);
  264.         if ((t = FindArg("-numaxis"))) {
  265.             NumAxis = atoi(Args[t+1]);
  266.         } else NumAxis = 2;
  267.         printf("Allocating %d axis Joystick\n", NumAxis);
  268.         if (!OpenAJoystick(AJOYUNIT1|(NumAxis==2?0:AJOYUNIT0))) {
  269.             printf("Joystick allocation failed\n");
  270.             mouse_switch_on();
  271.             return 0;
  272.         }
  273.         printf("Analog Joystick allocated successfully\n");
  274.         JP = malloc(sizeof(struct AJoyData));
  275.         if (!JP) {
  276.             CloseAJoystick();
  277.             mouse_switch_on();
  278.             return 0;
  279.         }
  280.         bzero(JP, sizeof(struct AJoyData));
  281.         Delay(25L);
  282.         joy_present = 1;
  283.         joy_installed = 1;
  284.         //joystick.max_timer = 65536;
  285.         joystick.slow_read = 0;
  286.         joystick.read_count = 0;
  287.         joystick.last_value = 0;
  288.         joy_handler = myjoy_handler;
  289.     }
  290.  
  291.     // Do initial cheapy calibration...
  292.     joystick.present_mask = JOY_ALL_AXIS;       // Assume they're all present
  293.     joystick.present_mask = joystick_read_raw_axis( JOY_ALL_AXIS, temp_axis );
  294.  
  295.     mouse_switch_on();
  296.     return 1;
  297. }
  298.  
  299. void joy_close()    
  300. {
  301.  
  302.     if (!joy_installed) return;
  303.     joy_installed = 0;
  304.     if (JP) {
  305.         free(JP); JP=0;
  306.         CloseAJoystick();
  307.     }
  308. }
  309.  
  310. void joy_set_ul()   
  311. {
  312.  
  313.     joystick.present_mask = JOY_ALL_AXIS;
  314.         joystick.present_mask = joystick_read_raw_axis( JOY_ALL_AXIS, joystick.axis_min );
  315.     if ( joystick.present_mask & 3 )
  316.         joy_present = 1;
  317.     else
  318.         joy_present = 0;
  319. }
  320.  
  321. void joy_set_lr()   
  322. {
  323.     joystick.present_mask = JOY_ALL_AXIS;
  324.     joystick.present_mask = joystick_read_raw_axis( JOY_ALL_AXIS, joystick.axis_max );
  325.  
  326.     if ( joystick.present_mask & 3 )
  327.         joy_present = 1;
  328.     else
  329.         joy_present = 0;
  330. }
  331.  
  332. void joy_set_cen() 
  333. {
  334.     joystick.present_mask = JOY_ALL_AXIS;
  335.     joystick.present_mask = joystick_read_raw_axis( JOY_ALL_AXIS, joystick.axis_center );
  336.  
  337.     if ( joystick.present_mask & 3 )
  338.         joy_present = 1;
  339.     else
  340.         joy_present = 0;
  341.  
  342. }
  343.  
  344. /*void dead_code_joy_set_cen_fake(int channel)
  345. {
  346. }*/
  347.  
  348. int joy_get_scaled_reading( int raw, int axn )  
  349. {
  350.     int x, d;
  351.  
  352.     if ( joystick.axis_center[axn] - joystick.axis_min[axn] < 5 ) return 0;
  353.     if ( joystick.axis_max[axn] - joystick.axis_center[axn] < 5 ) return 0;
  354.  
  355.     raw -= joystick.axis_center[axn];
  356.  
  357.     if ( raw < 0 )  {
  358.         d = joystick.axis_center[axn]-joystick.axis_min[axn];
  359.     } else {
  360.         d = joystick.axis_max[axn]-joystick.axis_center[axn];
  361.     }
  362.  
  363. #ifdef JOY_DEBUG
  364.     printf("raw=%d, d=%d\n", raw, d);
  365. #endif
  366.  
  367.     if ( d )
  368.         x = (raw << 7) / d;
  369.     else 
  370.         x = 0;
  371.  
  372.     if ( x < -128 ) x = -128;
  373.     if ( x > 127 ) x = 127;
  374. #ifdef JOY_DEBUG
  375.     printf("joy_get_scaled_reading(%d,%d) = %d\n", raw, axn, x);
  376. #endif
  377.  
  378.     return x;
  379. }
  380.  
  381. int last_reading[4] = { 0, 0, 0, 0 };
  382.  
  383. void joy_get_pos( int *x, int *y )  
  384. {
  385.     ubyte flags;
  386.     int axis[4];
  387.  
  388.     if ((!joy_installed)||(!joy_present)) { *x=*y=0; return; }
  389.  
  390.     flags=joystick_read_raw_axis( JOY_1_X_AXIS+JOY_1_Y_AXIS, axis );
  391.  
  392.     last_reading[0] = axis[0];
  393.     last_reading[1] = axis[1];
  394.  
  395.     if ( flags & JOY_1_X_AXIS )
  396.         *x = joy_get_scaled_reading( axis[0], 0 );
  397.     else
  398.         *x = 0;
  399.  
  400.     if ( flags & JOY_1_Y_AXIS )
  401.         *y = joy_get_scaled_reading( axis[1], 1 );
  402.     else
  403.         *y = 0;
  404.  
  405. #ifdef JOY_DEBUG
  406.     printf("joy_get_pos(%d,%d)\n", *x, *y);
  407. #endif
  408.  
  409. }
  410.  
  411. ubyte joy_read_stick( ubyte masks, int *axis )  
  412. {
  413.     ubyte flags;
  414.     int raw_axis[4];
  415.  
  416.     if ((!joy_installed)||(!joy_present)) { 
  417.         axis[0] = 0; axis[1] = 0;
  418.         axis[2] = 0; axis[3] = 0;
  419.         return 0;  
  420.     }
  421.  
  422.     flags=joystick_read_raw_axis( masks, raw_axis );
  423.  
  424.         last_reading[0] = axis[0];
  425.         last_reading[1] = axis[1];
  426.         last_reading[2] = axis[2];
  427.         last_reading[3] = axis[3];
  428.  
  429.     if ( flags & JOY_1_X_AXIS )
  430.         axis[0] = joy_get_scaled_reading( raw_axis[0], 0 );
  431.     else
  432.         axis[0] = 0;
  433.  
  434.     if ( flags & JOY_1_Y_AXIS )
  435.         axis[1] = joy_get_scaled_reading( raw_axis[1], 1 );
  436.     else
  437.         axis[1] = 0;
  438.  
  439.     if ( flags & JOY_2_X_AXIS )
  440.         axis[2] = joy_get_scaled_reading( raw_axis[2], 2 );
  441.     else
  442.         axis[2] = 0;
  443.  
  444.     if ( flags & JOY_2_Y_AXIS )
  445.         axis[3] = joy_get_scaled_reading( raw_axis[3], 3 );
  446.     else
  447.         axis[3] = 0;
  448. #ifdef JOY_DEBUG
  449.     printf("joy_read_stick: %d %d %d %d flags=%d\n",
  450.         axis[0], axis[1], axis[2], axis[3], flags);
  451. #endif
  452.     return flags;
  453. }
  454.  
  455.  
  456. int joy_get_btns()  
  457. {
  458.     if ((!joy_installed)||(!joy_present)) return 0;
  459.  
  460.      return joy_read_raw_buttons();
  461. }
  462.  
  463. void joy_get_btn_down_cnt( int *btn0, int *btn1 ) 
  464. {
  465.     if ((!joy_installed)||(!joy_present)) { *btn0=*btn1=0; return; }
  466.  
  467.     *btn0 = joystick.buttons[0].downcount;
  468.     joystick.buttons[0].downcount = 0;
  469.     *btn1 = joystick.buttons[1].downcount;
  470.     joystick.buttons[1].downcount = 0;
  471. }
  472.  
  473. int joy_get_button_state( int btn ) 
  474. {
  475.     int count;
  476.  
  477.     if ((!joy_installed)||(!joy_present)) return 0;
  478.  
  479.     if ( btn >= MAX_BUTTONS ) return 0;
  480.  
  481.     count = joystick.buttons[btn].state;
  482.  
  483.     return  count;
  484. }
  485.  
  486. int joy_get_button_up_cnt( int btn ) 
  487. {
  488.     int count;
  489.  
  490.     if ((!joy_installed)||(!joy_present)) return 0;
  491.  
  492.     if ( btn >= MAX_BUTTONS ) return 0;
  493.  
  494.     count = joystick.buttons[btn].upcount;
  495.     joystick.buttons[btn].upcount = 0;
  496.  
  497.     return count;
  498. }
  499.  
  500. int joy_get_button_down_cnt( int btn ) 
  501. {
  502.     int count;
  503.  
  504.     if ((!joy_installed)||(!joy_present)) return 0;
  505.     if ( btn >= MAX_BUTTONS ) return 0;
  506.  
  507.     count = joystick.buttons[btn].downcount;
  508.     joystick.buttons[btn].downcount = 0;
  509.     return count;
  510. }
  511.  
  512.     
  513. fix joy_get_button_down_time( int btn ) 
  514. {
  515.     fix count;
  516.  
  517.     if ((!joy_installed)||(!joy_present)) return 0;
  518.     if ( btn >= MAX_BUTTONS ) return 0;
  519.  
  520.     count = joystick.buttons[btn].timedown;
  521.     joystick.buttons[btn].timedown = 0;
  522.  
  523. //    return fixmuldiv(count, 65536, 1193180 );
  524.     return count;
  525. }
  526.  
  527. void joy_get_btn_up_cnt( int *btn0, int *btn1 ) 
  528. {
  529.     if ((!joy_installed)||(!joy_present)) { *btn0=*btn1=0; return; }
  530.  
  531.     *btn0 = joystick.buttons[0].upcount;
  532.     joystick.buttons[0].upcount = 0;
  533.     *btn1 = joystick.buttons[1].upcount;
  534.     joystick.buttons[1].upcount = 0;
  535.  
  536. }
  537.  
  538. void joy_set_btn_values( int btn, int state, fix timedown, int downcount, int upcount )
  539. {
  540.  
  541.     joystick.buttons[btn].ignore = 1;
  542.     joystick.buttons[btn].state = state;
  543.     joystick.buttons[btn].timedown = fixmuldiv( timedown, 1193180, 65536 );
  544.     joystick.buttons[btn].downcount = downcount;
  545.     joystick.buttons[btn].upcount = upcount;
  546. }
  547.  
  548. void joy_poll()
  549. {
  550. #ifdef JOY_DEBUG
  551.     printf("joy_poll()\n");
  552. #endif
  553. /*
  554.     if ( joystick.slow_read & JOY_BIOS_READINGS )   
  555.         joystick.last_value = joy_read_buttons_bios();
  556.     */
  557. }
  558.